{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.fftpack import fft,ifft\n",
    "import pandas as pd\n",
    "from scipy.optimize import minimize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 参考 08 Arevalo 取log bin的函数\n",
    "\n",
    "def databin_are(lst,f):\n",
    "    result = [[]]\n",
    "    f_length = len(f)\n",
    "    f_i = f[0]\n",
    "    for i in range(f_length):\n",
    "        if f[i]<=1.3*f_i:\n",
    "            result[-1].append(math.log(lst[i],10))\n",
    "        else:\n",
    "            if len(result[-1])<=2:\n",
    "                result[-1].append(math.log(lst[i],10))\n",
    "            else:\n",
    "                result.append([])\n",
    "                result[-1].append(math.log(lst[i],10))\n",
    "                f_i = f[i]\n",
    "    result.pop()\n",
    "    output=[]\n",
    "    for j in range(len(result)):\n",
    "        output.append(np.mean(result[j]))\n",
    "    return output        \n",
    "            \n",
    "\n",
    "def databin_are_std(lst,f):\n",
    "    result = [[]]\n",
    "    f_length = len(f)\n",
    "    f_i = f[0]\n",
    "    for i in range(f_length):\n",
    "        if f[i]<=1.3*f_i:\n",
    "            result[-1].append(math.log(lst[i],10))\n",
    "        else:\n",
    "            if len(result[-1])<=2:\n",
    "                result[-1].append(math.log(lst[i],10))\n",
    "            else:\n",
    "                result.append([])\n",
    "                result[-1].append(math.log(lst[i],10))\n",
    "                f_i = f[i]\n",
    "    result.pop()\n",
    "    output=[]\n",
    "    for j in range(len(result)):\n",
    "        output.append(np.std(result[j]))\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mrk335\n",
    "\n",
    "dt=50\n",
    "\n",
    "#06\n",
    "data06 = pd.read_csv(\"0.3_10_tb50.csv\")\n",
    "data06['RATE'] = data06['RATE'].interpolate()\n",
    "counts_data = data06['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_06 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_06 = databin_are(F1,F1)\n",
    "per_data_binned_06 = databin_are(per_data,F1)\n",
    "per_data_b_std_06 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_06 = np.array(F1_binned_06)+np.array(per_data_binned_06)\n",
    "\n",
    "\n",
    "\n",
    "#00\n",
    "data00 = pd.read_csv(\"03_10_tb50(00).csv\")  \n",
    "data00['RATE'] = data00['RATE'].interpolate()\n",
    "counts_data = data00['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_00 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_00 = databin_are(F1,F1)\n",
    "per_data_binned_00 = databin_are(per_data,F1)\n",
    "per_data_b_std_00 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_00 = np.array(F1_binned_00)+np.array(per_data_binned_00)\n",
    "\n",
    "\n",
    "\n",
    "#091\n",
    "data091 = pd.read_csv(\"03_10_tb50(091).csv\")  \n",
    "data091['RATE'] = data091['RATE'].interpolate()\n",
    "counts_data = data091['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_091 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_091 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_091 = databin_are(F1,F1)\n",
    "per_data_binned_091 = databin_are(per_data,F1)\n",
    "per_data_b_std_091 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_091 = np.array(F1_binned_091)+np.array(per_data_binned_091)\n",
    "\n",
    "\n",
    "\n",
    "#092\n",
    "data092 = pd.read_csv(\"03_10_tb50(092).csv\")  \n",
    "data092['RATE'] = data092['RATE'].interpolate()\n",
    "counts_data = data092['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_092 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_092 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_092 = databin_are(F1,F1)\n",
    "per_data_binned_092 = databin_are(per_data,F1)\n",
    "per_data_b_std_092 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_092 = np.array(F1_binned_092)+np.array(per_data_binned_092)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1H0707-495\n",
    "\n",
    "dt=50\n",
    "\n",
    "\n",
    "#081\n",
    "data081 = pd.read_csv(\"1H0707495_081_rate_0310_tb50_sel.csv\")\n",
    "data081['RATE'] = data081['RATE'].interpolate()\n",
    "counts_data = data081['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_081 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_081 = databin_are(F1,F1)\n",
    "per_data_binned_081 = databin_are(per_data,F1)\n",
    "per_data_b_std_081 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_081 = np.array(F1_binned_081)+np.array(per_data_binned_081)\n",
    "\n",
    "\n",
    "#101\n",
    "data101 = pd.read_csv(\"1H0707495_101_rate_0310_tb50_sel.csv\")\n",
    "data101['RATE'] = data101['RATE'].interpolate()\n",
    "counts_data = data101['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_101 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_101 = databin_are(F1,F1)\n",
    "per_data_binned_101 = databin_are(per_data,F1)\n",
    "per_data_b_std_101 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_101 = np.array(F1_binned_101)+np.array(per_data_binned_101)\n",
    "\n",
    "\n",
    "#102\n",
    "data102 = pd.read_csv(\"1H0707495_102_rate_0310_tb50_sel.csv\")\n",
    "data102['RATE'] = data102['RATE'].interpolate()\n",
    "counts_data = data102['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_102 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_102 = databin_are(F1,F1)\n",
    "per_data_binned_102 = databin_are(per_data,F1)\n",
    "per_data_b_std_102 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_102 = np.array(F1_binned_102)+np.array(per_data_binned_102)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PG1244+026\n",
    "\n",
    "dt=50\n",
    "\n",
    "#11\n",
    "data11 = pd.read_csv(\"PG_11_rate_0310_tb50.csv\")\n",
    "data11['RATE'] = data11['RATE'].interpolate()\n",
    "counts_data = data11['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_11 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_11 = databin_are(F1,F1)\n",
    "per_data_binned_11 = databin_are(per_data,F1)\n",
    "per_data_b_std_11 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_11 = np.array(F1_binned_11)+np.array(per_data_binned_11)\n",
    "\n",
    "\n",
    "#142\n",
    "data142 = pd.read_csv(\"PG_142_rate_0310_tb50_sel.csv\")\n",
    "data142['RATE'] = data142['RATE'].interpolate()\n",
    "counts_data = data142['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_142 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_00 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_142 = databin_are(F1,F1)\n",
    "per_data_binned_142 = databin_are(per_data,F1)\n",
    "per_data_b_std_142 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_142 = np.array(F1_binned_142)+np.array(per_data_binned_142)\n",
    "\n",
    "\n",
    "#15\n",
    "data15 = pd.read_csv(\"PG_15_rate_0310_tb50_sel.csv\")\n",
    "data15['RATE'] = data15['RATE'].interpolate()\n",
    "counts_data = data15['RATE']\n",
    "N=len(counts_data)\n",
    "pnum = np.arange(len(counts_data))\n",
    "t = [i*dt for i in pnum]\n",
    "\n",
    "nf = N/2\n",
    "df = 1/(dt*N)\n",
    "F_a = np.arange(1,nf+1)\n",
    "F = [i*df for i in F_a]\n",
    "F1 = F[0:int(nf)]\n",
    "mean_x = np.mean(counts_data)\n",
    "dft = fft(counts_data)\n",
    "dft1= dft[1:int(nf)+1]\n",
    "per_data = (abs(dft1)**2)*2*dt/((mean_x**2)*N)\n",
    "p_times_f_data = np.multiply(np.array(F1),np.array(per_data))\n",
    "\n",
    "F1_log_15 = [math.log(i,10) for i in F1]\n",
    "ptf_data_log_15 = [math.log(i,10) for i in p_times_f_data]\n",
    "F1_binned_15 = databin_are(F1,F1)\n",
    "per_data_binned_15 = databin_are(per_data,F1)\n",
    "per_data_b_std_15 = databin_are_std(per_data,F1)\n",
    "p_times_f_data_b_15 = np.array(F1_binned_15)+np.array(per_data_binned_15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig= plt.figure(figsize=(20,20))\n",
    "ax1 = plt.subplot(221)\n",
    "ax2 = plt.subplot(222)\n",
    "ax3 = plt.subplot(223)\n",
    "ax4 = plt.subplot(224)\n",
    "\n",
    "ax1.step(F1_binned_06, p_times_f_data_b_06, where='mid',color=\"b\", label='2006')\n",
    "ax1.step(F1_binned_091, p_times_f_data_b_091, where='mid', color=\"g\", label='2006')\n",
    "ax1.step(F1_binned_092, p_times_f_data_b_092, where='mid', color=\"r\",label='2009(2)')\n",
    "ax3.step(F1_binned_06, p_times_f_data_b_06, where='mid',color=\"b\", label='2006')\n",
    "ax3.step(F1_binned_091, p_times_f_data_b_091, where='mid', color=\"g\", label='2006')\n",
    "ax3.step(F1_binned_092, p_times_f_data_b_092, where='mid', color=\"r\",label='2009(2)')\n",
    "\n",
    "#ax1.errorbar(F1_binned_06, p_times_f_data_b_06, yerr=per_data_b_std_06, fmt=',',color=\"b\")\n",
    "#ax1.errorbar(F1_binned_091, p_times_f_data_b_091, yerr=per_data_b_std_091, fmt=',',color=\"g\")\n",
    "#ax1.errorbar(F1_binned_092, p_times_f_data_b_092, yerr=per_data_b_std_092, fmt=',',color=\"r\")\n",
    "#ax3.errorbar(F1_binned_06, p_times_f_data_b_06, yerr=per_data_b_std_06, fmt=',',color=\"b\")\n",
    "#ax3.errorbar(F1_binned_091, p_times_f_data_b_091, yerr=per_data_b_std_091, fmt=',',color=\"g\")\n",
    "#ax3.errorbar(F1_binned_092, p_times_f_data_b_092, yerr=per_data_b_std_092, fmt=',',color=\"r\")\n",
    "\n",
    "\n",
    "ax1.set_xlabel(\"log frequency\",fontsize=20)\n",
    "ax1.set_ylabel(\"log power*frequency\",fontsize=20)\n",
    "ax1.set_xlim(-5.0,-2.0)\n",
    "ax1.set_ylim(-5,0)\n",
    "ax1.tick_params(labelsize=15)\n",
    "ax1.set_title(\"PSD Mrk335\",fontsize=23)\n",
    "ax1.legend()\n",
    "\n",
    "ax3.set_xlabel(\"log frequency\",fontsize=20)\n",
    "ax3.set_ylabel(\"log power*frequency\",fontsize=20)\n",
    "ax3.set_xlim(-5.0,-2.0)\n",
    "ax3.set_ylim(-5,0)\n",
    "ax3.tick_params(labelsize=15)\n",
    "ax3.set_title(\"PSD Mrk335\",fontsize=23)\n",
    "ax3.legend()\n",
    "\n",
    "\n",
    "ax4.step(F1_binned_081, p_times_f_data_b_081, where='mid',color=\"b\",label='2015')\n",
    "ax4.step(F1_binned_101, p_times_f_data_b_101, where='mid',color=\"g\", label='2010(1)')\n",
    "ax4.step(F1_binned_102, p_times_f_data_b_102, where='mid', color=\"r\",label='2010(2)')\n",
    "#ax4.errorbar(F1_binned_081, p_times_f_data_b_081, yerr=per_data_b_std_081, fmt=',',color=\"b\")\n",
    "#ax4.errorbar(F1_binned_101, p_times_f_data_b_101, yerr=per_data_b_std_101, fmt=',',color=\"g\")\n",
    "#ax4.errorbar(F1_binned_102, p_times_f_data_b_102, yerr=per_data_b_std_102, fmt=',',color=\"r\")\n",
    "\n",
    "ax4.set_xlabel(\"log frequency\",fontsize=20)\n",
    "ax4.set_ylabel(\"log power*frequency\",fontsize=20)\n",
    "ax4.set_xlim(-5.0,-2.0)\n",
    "ax4.set_ylim(-5,0)\n",
    "ax4.tick_params(labelsize=15)\n",
    "ax4.set_title(\"PSD 1H0707-495\",fontsize=23)\n",
    "ax4.legend()\n",
    "\n",
    "\n",
    "ax2.step(F1_binned_11, p_times_f_data_b_11, where='mid',color=\"b\", label='2011')\n",
    "ax2.step(F1_binned_142, p_times_f_data_b_142, where='mid',color=\"g\", label='2014(2)')\n",
    "ax2.step(F1_binned_15, p_times_f_data_b_15, where='mid', color=\"r\",label='2015')\n",
    "#ax2.errorbar(F1_binned_11, p_times_f_data_b_11, yerr=per_data_b_std_11, fmt=',',color=\"b\")\n",
    "#ax2.errorbar(F1_binned_142, p_times_f_data_b_142, yerr=per_data_b_std_142, fmt=',',color=\"g\")\n",
    "#ax2.errorbar(F1_binned_15, p_times_f_data_b_15, yerr=per_data_b_std_15, fmt=',',color=\"r\")\n",
    "\n",
    "ax2.set_xlabel(\"log frequency\",fontsize=20)\n",
    "ax2.set_ylabel(\"log power*frequency\",fontsize=20)\n",
    "ax2.set_xlim(-5.0,-2.0)\n",
    "ax2.set_ylim(-5,0)\n",
    "ax2.tick_params(labelsize=15)\n",
    "ax2.set_title(\"PSD PG1244+026\",fontsize=23)\n",
    "ax2.legend()\n",
    "\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
